home *** CD-ROM | disk | FTP | other *** search
/ Hardcore Visual Basic 5.0 (2nd Edition) / Hardcore Visual Basic 5.0 - Second Edition (1997)(Microsoft Press).iso / Source / Cpp4VB / WINTLB / OLEAUTO.ODL < prev    next >
Text File  |  1996-02-27  |  11KB  |  298 lines
  1.  
  2. [
  3. uuid(5467404A-3A82-101B-8181-00AA003743D3),
  4. helpstring("OLE Automation Functions"),
  5. #ifdef WIN32
  6. dllname("OLEAUT32.DLL")
  7. #else
  8. dllname("OLE2DISP.DLL")
  9. #endif
  10. ]
  11. module OleAuto {
  12.  
  13.     //----------
  14.     // BSTR API
  15.     //----------
  16.  
  17.     [
  18.     usesgetlasterror,
  19.     entry("SysAllocString"),
  20.     helpstring("Allocates and returns a BSTR for a given LPSTR"),
  21.     ]
  22.     BSTR WINAPI SysAllocString([in] LPSTR sz);
  23.  
  24.     [
  25.     usesgetlasterror,
  26.     entry("SysReAllocString"),
  27.     helpstring("Reallocates a BSTR, assigning it the value of a given BSTR and freeing the old data (returns true or false)"),
  28.     ]
  29.     BOOL WINAPI SysReAllocString([in] BSTR pbstr,
  30.                                  [in] LPSTR sz);
  31.  
  32.     [
  33.     usesgetlasterror,
  34.     entry("SysAllocStringLen"),
  35.     helpstring("Allocates and returns a BSTR using the given number of characters from a given LPSTR"),
  36.     ]
  37.     BSTR WINAPI SysAllocStringLen([in] LPSTR sz, [in] UINT len);
  38.  
  39.     [
  40.     usesgetlasterror,
  41.     entry("SysReAllocStringLen"),
  42.     helpstring("Reallocates a BSTR, assigning it a given number of characters from a given BSTR and freeing the old data (returns true or false)"),
  43.     ]
  44.     int  WINAPI SysReAllocStringLen([in] BSTR pbstr,
  45.                                     [in] LPSTR pch,
  46.                                     [in] UINT cch);
  47.  
  48.     [
  49.     usesgetlasterror,
  50.     entry("SysFreeString"),
  51.     helpstring("Frees a BSTR"),
  52.     ]
  53.     void WINAPI SysFreeString([in] BSTR bstr);
  54.  
  55.     [
  56.     usesgetlasterror,
  57.     entry("SysStringLen"),
  58.     helpstring("Returns the length in characters of a BSTR"),
  59.     ]
  60.     UINT WINAPI SysStringLen([in] BSTR bstr);
  61.  
  62.     #ifdef WIN32
  63.     [
  64.     usesgetlasterror,
  65.     entry("SysStringByteLen"),
  66.     helpstring("Returns the length in bytes of a BSTR"),
  67.     ]
  68.     UINT WINAPI SysStringByteLen([in] BSTR bstr);
  69.  
  70.     [
  71.     usesgetlasterror,
  72.     entry("SysAllocStringByteLen"),
  73.     helpstring("Allocates and returns a BSTR using the given number of bytes from a given LPSTR"),
  74.     ]
  75.     BSTR WINAPI SysAllocStringByteLen([in] LPSTR psz,
  76.                                       [in] UINT len);
  77.     #endif
  78.  
  79.     //----------
  80.     // Time API
  81.     //----------
  82.  
  83.     [
  84.     usesgetlasterror,
  85.     entry("DosDateTimeToVariantTime"),
  86.     helpstring("Converts a DOS packed date and time to the floating point format stored in variants"),
  87.     ]
  88.     int WINAPI DosDateTimeToVariantTime(
  89.         [in] unsigned short wDosDate,
  90.         [in] unsigned short wDosTime,
  91.         [out] double FAR* pvtime);
  92.  
  93.     [
  94.     usesgetlasterror,
  95.     entry("VariantTimeToDosDateTime"),
  96.     helpstring("Converts the floating point format stored in variants to a DOS packed date and time"),
  97.     ]
  98.     int WINAPI VariantTimeToDosDateTime(
  99.         [in] double vtime,
  100.         [out] unsigned short FAR* pwDosDate,
  101.         [out] unsigned short FAR* pwDosTime);
  102.  
  103.  
  104.     //---------------
  105.     // SafeArray API
  106.     //---------------
  107.  
  108.     /* SafeArray omitted
  109.  
  110.     STDAPI
  111.     SafeArrayAllocDescriptor(unsigned int cDims, SAFEARRAY FAR* FAR* ppsaOut);
  112.  
  113.     STDAPI SafeArrayAllocData(SAFEARRAY FAR* psa);
  114.  
  115.     STDAPI_(SAFEARRAY FAR*)
  116.     SafeArrayCreate(
  117.         VARTYPE vt,
  118.         unsigned int cDims,
  119.         SAFEARRAYBOUND FAR* rgsabound);
  120.  
  121.     STDAPI SafeArrayDestroyDescriptor(SAFEARRAY FAR* psa);
  122.  
  123.     STDAPI SafeArrayDestroyData(SAFEARRAY FAR* psa);
  124.  
  125.     STDAPI SafeArrayDestroy(SAFEARRAY FAR* psa);
  126.  
  127.     STDAPI SafeArrayRedim(SAFEARRAY FAR* psa, SAFEARRAYBOUND FAR* psaboundNew);
  128.  
  129.     STDAPI_(unsigned int) SafeArrayGetDim(SAFEARRAY FAR* psa);
  130.  
  131.     STDAPI_(unsigned int) SafeArrayGetElemsize(SAFEARRAY FAR* psa);
  132.  
  133.     STDAPI
  134.     SafeArrayGetUBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plUbound);
  135.  
  136.     STDAPI
  137.     SafeArrayGetLBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plLbound);
  138.  
  139.     STDAPI SafeArrayLock(SAFEARRAY FAR* psa);
  140.  
  141.     STDAPI SafeArrayUnlock(SAFEARRAY FAR* psa);
  142.  
  143.     STDAPI SafeArrayAccessData(SAFEARRAY FAR* psa, void HUGEP* FAR* ppvData);
  144.  
  145.     STDAPI SafeArrayUnaccessData(SAFEARRAY FAR* psa);
  146.  
  147.     STDAPI
  148.     SafeArrayGetElement(
  149.         SAFEARRAY FAR* psa,
  150.         long FAR* rgIndices,
  151.         void FAR* pv);
  152.  
  153.     STDAPI
  154.     SafeArrayPutElement(
  155.         SAFEARRAY FAR* psa,
  156.         long FAR* rgIndices,
  157.         void FAR* pv);
  158.  
  159.     STDAPI
  160.     SafeArrayCopy(
  161.         SAFEARRAY FAR* psa,
  162.         SAFEARRAY FAR* FAR* ppsaOut);
  163.     */
  164.  
  165.     //-------------
  166.     // VARIANT API
  167.     //-------------
  168.  
  169.     /* Variant omitted
  170.     STDAPI_(void)
  171.     VariantInit(VARIANTARG FAR* pvarg);
  172.  
  173.     STDAPI
  174.     VariantClear(VARIANTARG FAR* pvarg);
  175.  
  176.     STDAPI
  177.     VariantCopy(
  178.         VARIANTARG FAR* pvargDest,
  179.         VARIANTARG FAR* pvargSrc);
  180.  
  181.     STDAPI
  182.     VariantCopyInd(
  183.         VARIANT FAR* pvarDest,
  184.         VARIANTARG FAR* pvargSrc);
  185.  
  186.     STDAPI
  187.     VariantChangeType(
  188.         VARIANTARG FAR* pvargDest,
  189.         VARIANTARG FAR* pvarSrc,
  190.         unsigned short wFlags,
  191.         VARTYPE vt);
  192.  
  193.     STDAPI
  194.     VariantChangeTypeEx(
  195.         VARIANTARG FAR* pvargDest,
  196.         VARIANTARG FAR* pvarSrc,
  197.         LCID lcid,
  198.         unsigned short wFlags,
  199.         VARTYPE vt);
  200.  
  201.     //define VARIANT_NOVALUEPROP 1
  202.     */
  203.  
  204.     //----------------------
  205.     // VARTYPE Coercion API
  206.     //----------------------
  207.  
  208.     // Note: The routines that convert *from* a string are defined
  209.     // to take a char* rather than a BSTR because no allocation is
  210.     // required, and this makes the routines a bit more generic.
  211.     // They may of course still be passed a BSTR as the strIn param.
  212.  
  213.     // Any of the coersion functions that converts either from or to a string
  214.     // takes an additional lcid and dwFlags arguments. The lcid argument allows
  215.     // locale specific parsing to occur.  The dwFlags allow additional function
  216.     // specific condition to occur.  All function that accept the dwFlags argument
  217.     // can include either 0 or LOCALE_NOUSEROVERRIDE flag. In addition, the
  218.     // VarDateFromStr functions also accepts the VAR_TIMEVALUEONLY and
  219.     // VAR_DATEVALUEONLY flags
  220.  
  221.     /*
  222.     //define VAR_TIMEVALUEONLY           0x0001    // return time value
  223.     //define VAR_DATEVALUEONLY           0x0002    // return date value
  224.  
  225.     STDAPI VarI2FromI4(long lIn, short FAR* psOut);
  226.     STDAPI VarI2FromR4(float fltIn, short FAR* psOut);
  227.     STDAPI VarI2FromR8(double dblIn, short FAR* psOut);
  228.     STDAPI VarI2FromCy(CY cyIn, short FAR* psOut);
  229.     STDAPI VarI2FromDate(DATE dateIn, short FAR* psOut);
  230.     STDAPI VarI2FromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, short FAR* psOut);
  231.     STDAPI VarI2FromDisp(IDispatch FAR* pdispIn, LCID lcid, short FAR* psOut);
  232.     STDAPI VarI2FromBool(VARIANT_BOOL boolIn, short FAR* psOut);
  233.  
  234.     STDAPI VarI4FromI2(short sIn, long FAR* plOut);
  235.     STDAPI VarI4FromR4(float fltIn, long FAR* plOut);
  236.     STDAPI VarI4FromR8(double dblIn, long FAR* plOut);
  237.     STDAPI VarI4FromCy(CY cyIn, long FAR* plOut);
  238.     STDAPI VarI4FromDate(DATE dateIn, long FAR* plOut);
  239.     STDAPI VarI4FromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, long FAR* plOut);
  240.     STDAPI VarI4FromDisp(IDispatch FAR* pdispIn, LCID lcid, long FAR* plOut);
  241.     STDAPI VarI4FromBool(VARIANT_BOOL boolIn, long FAR* plOut);
  242.  
  243.     STDAPI VarR4FromI2(short sIn, float FAR* pfltOut);
  244.     STDAPI VarR4FromI4(long lIn, float FAR* pfltOut);
  245.     STDAPI VarR4FromR8(double dblIn, float FAR* pfltOut);
  246.     STDAPI VarR4FromCy(CY cyIn, float FAR* pfltOut);
  247.     STDAPI VarR4FromDate(DATE dateIn, float FAR* pfltOut);
  248.     STDAPI VarR4FromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, float FAR* pfltOut);
  249.     STDAPI VarR4FromDisp(IDispatch FAR* pdispIn, LCID lcid, float FAR* pfltOut);
  250.     STDAPI VarR4FromBool(VARIANT_BOOL boolIn, float FAR* pfltOut);
  251.  
  252.     STDAPI VarR8FromI2(short sIn, double FAR* pdblOut);
  253.     STDAPI VarR8FromI4(long lIn, double FAR* pdblOut);
  254.     STDAPI VarR8FromR4(float fltIn, double FAR* pdblOut);
  255.     STDAPI VarR8FromCy(CY cyIn, double FAR* pdblOut);
  256.     STDAPI VarR8FromDate(DATE dateIn, double FAR* pdblOut);
  257.     STDAPI VarR8FromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, double FAR* pdblOut);
  258.     STDAPI VarR8FromDisp(IDispatch FAR* pdispIn, LCID lcid, double FAR* pdblOut);
  259.     STDAPI VarR8FromBool(VARIANT_BOOL boolIn, double FAR* pdblOut);
  260.  
  261.     STDAPI VarDateFromI2(short sIn, DATE FAR* pdateOut);
  262.     STDAPI VarDateFromI4(long lIn, DATE FAR* pdateOut);
  263.     STDAPI VarDateFromR4(float fltIn, DATE FAR* pdateOut);
  264.     STDAPI VarDateFromR8(double dblIn, DATE FAR* pdateOut);
  265.     STDAPI VarDateFromCy(CY cyIn, DATE FAR* pdateOut);
  266.     STDAPI VarDateFromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, DATE FAR* pdateOut);
  267.     STDAPI VarDateFromDisp(IDispatch FAR* pdispIn, LCID lcid, DATE FAR* pdateOut);
  268.     STDAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE FAR* pdateOut);
  269.  
  270.     STDAPI VarCyFromI2(short sIn, CY FAR* pcyOut);
  271.     STDAPI VarCyFromI4(long lIn, CY FAR* pcyOut);
  272.     STDAPI VarCyFromR4(float fltIn, CY FAR* pcyOut);
  273.     STDAPI VarCyFromR8(double dblIn, CY FAR* pcyOut);
  274.     STDAPI VarCyFromDate(DATE dateIn, CY FAR* pcyOut);
  275.     STDAPI VarCyFromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, CY FAR* pcyOut);
  276.     STDAPI VarCyFromDisp(IDispatch FAR* pdispIn, LCID lcid, CY FAR* pcyOut);
  277.     STDAPI VarCyFromBool(VARIANT_BOOL boolIn, CY FAR* pcyOut);
  278.  
  279.     STDAPI VarBstrFromI2(short iVal, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  280.     STDAPI VarBstrFromI4(long lIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  281.     STDAPI VarBstrFromR4(float fltIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  282.     STDAPI VarBstrFromR8(double dblIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  283.     STDAPI VarBstrFromCy(CY cyIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  284.     STDAPI VarBstrFromDate(DATE dateIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  285.     STDAPI VarBstrFromDisp(IDispatch FAR* pdispIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  286.     STDAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  287.  
  288.     STDAPI VarBoolFromI2(short sIn, VARIANT_BOOL FAR* pboolOut);
  289.     STDAPI VarBoolFromI4(long lIn, VARIANT_BOOL FAR* pboolOut);
  290.     STDAPI VarBoolFromR4(float fltIn, VARIANT_BOOL FAR* pboolOut);
  291.     STDAPI VarBoolFromR8(double dblIn, VARIANT_BOOL FAR* pboolOut);
  292.     STDAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL FAR* pboolOut);
  293.     STDAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL FAR* pboolOut);
  294.     STDAPI VarBoolFromStr(TCHAR FAR* strIn, LCID lcid, unsigned long dwFlags, VARIANT_BOOL FAR* pboolOut);
  295.     STDAPI VarBoolFromDisp(IDispatch FAR* pdispIn, LCID lcid, VARIANT_BOOL FAR* pboolOut);
  296.     */
  297. }
  298.